/*
 * chap_ms.c - Microsoft MS-CHAP compatible implementation.
 *
 * Copyright (c) 1995 Eric Rosenquist.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The name(s) of the authors of this software must not be used to
 *    endorse or promote products derived from this software without
 *    prior written permission.
 *
 * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO
 * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

/*
 * Modifications by Lauri Pesonen / lpesonen@clinet.fi, april 1997
 *
 *   Implemented LANManager type password response to MS-CHAP challenges.
 *   Now pppd provides both NT style and LANMan style blocks, and the
 *   preferred is set by option "ms-lanman". Default is to use NT.
 *   The hash text (StdText) was taken from Win95 RASAPI32.DLL.
 *
 *   You should also use DOMAIN\\USERNAME as described in README.MSCHAP80
 */

/*
 * Modifications by Frank Cusack, frank@google.com, March 2002.
 *
 *   Implemented MS-CHAPv2 functionality, heavily based on sample
 *   implementation in RFC 2759.  Implemented MPPE functionality,
 *   heavily based on sample implementation in RFC 3079.
 *
 * Copyright (c) 2002 Google, Inc.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The name(s) of the authors of this software must not be used to
 *    endorse or promote products derived from this software without
 *    prior written permission.
 *
 * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO
 * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 */

#include "netif/ppp/ppp_opts.h"
#if PPP_SUPPORT &&                                                             \
    MSCHAP_SUPPORT /* don't build if not configured for use in lwipopts.h */

#if 0 /* UNUSED */
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#endif /* UNUSED */

#include "netif/ppp/ppp_impl.h"

#include "netif/ppp/chap-new.h"
#include "netif/ppp/chap_ms.h"
#include "netif/ppp/magic.h"
#include "netif/ppp/pppcrypt.h"
#if MPPE_SUPPORT
#include "netif/ppp/mppe.h" /* For mppe_sha1_pad*, mppe_set_key() */
#endif                      /* MPPE_SUPPORT */

#define SHA1_SIGNATURE_SIZE 20
#define MD4_SIGNATURE_SIZE 16 /* 16 bytes in a MD4 message digest */
#define MAX_NT_PASSWORD 256   /* Max (Unicode) chars in an NT pass */

#define MS_CHAP_RESPONSE_LEN 49    /* Response length for MS-CHAP */
#define MS_CHAP2_RESPONSE_LEN 49   /* Response length for MS-CHAPv2 */
#define MS_AUTH_RESPONSE_LENGTH 40 /* MS-CHAPv2 authenticator response, */
                                   /* as ASCII */

/* Error codes for MS-CHAP failure messages. */
#define MS_CHAP_ERROR_RESTRICTED_LOGON_HOURS 646
#define MS_CHAP_ERROR_ACCT_DISABLED 647
#define MS_CHAP_ERROR_PASSWD_EXPIRED 648
#define MS_CHAP_ERROR_NO_DIALIN_PERMISSION 649
#define MS_CHAP_ERROR_AUTHENTICATION_FAILURE 691
#define MS_CHAP_ERROR_CHANGING_PASSWORD 709

/*
 * Offsets within the response field for MS-CHAP
 */
#define MS_CHAP_LANMANRESP 0
#define MS_CHAP_LANMANRESP_LEN 24
#define MS_CHAP_NTRESP 24
#define MS_CHAP_NTRESP_LEN 24
#define MS_CHAP_USENT 48

/*
 * Offsets within the response field for MS-CHAP2
 */
#define MS_CHAP2_PEER_CHALLENGE 0
#define MS_CHAP2_PEER_CHAL_LEN 16
#define MS_CHAP2_RESERVED_LEN 8
#define MS_CHAP2_NTRESP 24
#define MS_CHAP2_NTRESP_LEN 24
#define MS_CHAP2_FLAGS 48

#if MPPE_SUPPORT
#if 0 /* UNUSED */
/* These values are the RADIUS attribute values--see RFC 2548. */
#define MPPE_ENC_POL_ENC_ALLOWED 1
#define MPPE_ENC_POL_ENC_REQUIRED 2
#define MPPE_ENC_TYPES_RC4_40 2
#define MPPE_ENC_TYPES_RC4_128 4

/* used by plugins (using above values) */
extern void set_mppe_enc_types(int, int);
#endif /* UNUSED */
#endif /* MPPE_SUPPORT */

/* Are we the authenticator or authenticatee?  For MS-CHAPv2 key derivation. */
#define MS_CHAP2_AUTHENTICATEE 0
#define MS_CHAP2_AUTHENTICATOR 1

static void ascii2unicode(const char[], int, u_char[]);
static void NTPasswordHash(u_char *, int, u_char[MD4_SIGNATURE_SIZE]);
static void ChallengeResponse(const u_char *, const u_char *, u_char[24]);
static void ChallengeHash(const u_char[16], const u_char *, const char *,
                          u_char[8]);
static void ChapMS_NT(const u_char *, const char *, int, u_char[24]);
static void ChapMS2_NT(const u_char *, const u_char[16], const char *,
                       const char *, int, u_char[24]);
static void GenerateAuthenticatorResponsePlain(const char *, int, u_char[24],
                                               const u_char[16], const u_char *,
                                               const char *, u_char[41]);
#ifdef MSLANMAN
static void ChapMS_LANMan(u_char *, char *, int, u_char *);
#endif

static void GenerateAuthenticatorResponse(
    const u_char PasswordHashHash[MD4_SIGNATURE_SIZE], u_char NTResponse[24],
    const u_char PeerChallenge[16], const u_char *rchallenge,
    const char *username, u_char authResponse[MS_AUTH_RESPONSE_LENGTH + 1]);

#if MPPE_SUPPORT
static void Set_Start_Key(ppp_pcb *pcb, const u_char *, const char *, int);
static void SetMasterKeys(ppp_pcb *pcb, const char *, int, u_char[24], int);
#endif /* MPPE_SUPPORT */

static void ChapMS(ppp_pcb *pcb, const u_char *, const char *, int, u_char *);
static void ChapMS2(ppp_pcb *pcb, const u_char *, const u_char *, const char *,
                    const char *, int, u_char *,
                    u_char[MS_AUTH_RESPONSE_LENGTH + 1], int);

#ifdef MSLANMAN
bool ms_lanman = 0; /* Use LanMan password instead of NT */
                    /* Has meaning only with MS-CHAP challenges */
#endif

#if MPPE_SUPPORT
#ifdef DEBUGMPPEKEY
/* For MPPE debug */
/* Use "[]|}{?/><,`!2&&(" (sans quotes) for RFC 3079 MS-CHAPv2 test value */
static char *mschap_challenge = NULL;
/* Use "!@\#$%^&*()_+:3|~" (sans quotes, backslash is to escape #) for ... */
static char *mschap2_peer_challenge = NULL;
#endif

#include "netif/ppp/ccp.h"
#include "netif/ppp/fsm.h" /* Need to poke MPPE options */
#endif                     /* MPPE_SUPPORT */

#if PPP_OPTIONS
/*
 * Command-line options.
 */
static option_t chapms_option_list[] = {
#ifdef MSLANMAN
    {"ms-lanman", o_bool, &ms_lanman, "Use LanMan passwd when using MS-CHAP",
     1},
#endif
#ifdef DEBUGMPPEKEY
    {"mschap-challenge", o_string, &mschap_challenge, "specify CHAP challenge"},
    {"mschap2-peer-challenge", o_string, &mschap2_peer_challenge,
     "specify CHAP peer challenge"},
#endif
    {NULL}};
#endif /* PPP_OPTIONS */

#if PPP_SERVER
/*
 * chapms_generate_challenge - generate a challenge for MS-CHAP.
 * For MS-CHAP the challenge length is fixed at 8 bytes.
 * The length goes in challenge[0] and the actual challenge starts
 * at challenge[1].
 */
static void chapms_generate_challenge(ppp_pcb *pcb, unsigned char *challenge) {
  LWIP_UNUSED_ARG(pcb);

  *challenge++ = 8;
#ifdef DEBUGMPPEKEY
  if (mschap_challenge && strlen(mschap_challenge) == 8)
    memcpy(challenge, mschap_challenge, 8);
  else
#endif
    magic_random_bytes(challenge, 8);
}

static void chapms2_generate_challenge(ppp_pcb *pcb, unsigned char *challenge) {
  LWIP_UNUSED_ARG(pcb);

  *challenge++ = 16;
#ifdef DEBUGMPPEKEY
  if (mschap_challenge && strlen(mschap_challenge) == 16)
    memcpy(challenge, mschap_challenge, 16);
  else
#endif
    magic_random_bytes(challenge, 16);
}

static int chapms_verify_response(ppp_pcb *pcb, int id, const char *name,
                                  const unsigned char *secret, int secret_len,
                                  const unsigned char *challenge,
                                  const unsigned char *response, char *message,
                                  int message_space) {
  unsigned char md[MS_CHAP_RESPONSE_LEN];
  int diff;
  int challenge_len, response_len;
  LWIP_UNUSED_ARG(id);
  LWIP_UNUSED_ARG(name);

  challenge_len = *challenge++; /* skip length, is 8 */
  response_len = *response++;
  if (response_len != MS_CHAP_RESPONSE_LEN)
    goto bad;

#ifndef MSLANMAN
  if (!response[MS_CHAP_USENT]) {
    /* Should really propagate this into the error packet. */
    ppp_notice(("Peer request for LANMAN auth not supported"));
    goto bad;
  }
#endif

  /* Generate the expected response. */
  ChapMS(pcb, (const u_char *)challenge, (const char *)secret, secret_len, md);

#ifdef MSLANMAN
  /* Determine which part of response to verify against */
  if (!response[MS_CHAP_USENT])
    diff = memcmp(&response[MS_CHAP_LANMANRESP], &md[MS_CHAP_LANMANRESP],
                  MS_CHAP_LANMANRESP_LEN);
  else
#endif
    diff = memcmp(&response[MS_CHAP_NTRESP], &md[MS_CHAP_NTRESP],
                  MS_CHAP_NTRESP_LEN);

  if (diff == 0) {
    ppp_slprintf(message, message_space, "Access granted");
    return 1;
  }

bad:
  /* See comments below for MS-CHAP V2 */
  ppp_slprintf(message, message_space, "E=691 R=1 C=%0.*B V=0", challenge_len,
               challenge);
  return 0;
}

static int chapms2_verify_response(ppp_pcb *pcb, int id, const char *name,
                                   const unsigned char *secret, int secret_len,
                                   const unsigned char *challenge,
                                   const unsigned char *response, char *message,
                                   int message_space) {
  unsigned char md[MS_CHAP2_RESPONSE_LEN];
  char saresponse[MS_AUTH_RESPONSE_LENGTH + 1];
  int challenge_len, response_len;
  LWIP_UNUSED_ARG(id);

  challenge_len = *challenge++; /* skip length, is 16 */
  response_len = *response++;
  if (response_len != MS_CHAP2_RESPONSE_LEN)
    goto bad; /* not even the right length */

  /* Generate the expected response and our mutual auth. */
  ChapMS2(pcb, (const u_char *)challenge,
          (const u_char *)&response[MS_CHAP2_PEER_CHALLENGE], name,
          (const char *)secret, secret_len, md, (unsigned char *)saresponse,
          MS_CHAP2_AUTHENTICATOR);

  /* compare MDs and send the appropriate status */
  /*
   * Per RFC 2759, success message must be formatted as
   *     "S=<auth_string> M=<message>"
   * where
   *     <auth_string> is the Authenticator Response (mutual auth)
   *     <message> is a text message
   *
   * However, some versions of Windows (win98 tested) do not know
   * about the M=<message> part (required per RFC 2759) and flag
   * it as an error (reported incorrectly as an encryption error
   * to the user).  Since the RFC requires it, and it can be
   * useful information, we supply it if the peer is a conforming
   * system.  Luckily (?), win98 sets the Flags field to 0x04
   * (contrary to RFC requirements) so we can use that to
   * distinguish between conforming and non-conforming systems.
   *
   * Special thanks to Alex Swiridov <say@real.kharkov.ua> for
   * help debugging this.
   */
  if (memcmp(&md[MS_CHAP2_NTRESP], &response[MS_CHAP2_NTRESP],
             MS_CHAP2_NTRESP_LEN) == 0) {
    if (response[MS_CHAP2_FLAGS])
      ppp_slprintf(message, message_space, "S=%s", saresponse);
    else
      ppp_slprintf(message, message_space, "S=%s M=%s", saresponse,
                   "Access granted");
    return 1;
  }

bad:
  /*
   * Failure message must be formatted as
   *     "E=e R=r C=c V=v M=m"
   * where
   *     e = error code (we use 691, ERROR_AUTHENTICATION_FAILURE)
   *     r = retry (we use 1, ok to retry)
   *     c = challenge to use for next response, we reuse previous
   *     v = Change Password version supported, we use 0
   *     m = text message
   *
   * The M=m part is only for MS-CHAPv2.  Neither win2k nor
   * win98 (others untested) display the message to the user anyway.
   * They also both ignore the E=e code.
   *
   * Note that it's safe to reuse the same challenge as we don't
   * actually accept another response based on the error message
   * (and no clients try to resend a response anyway).
   *
   * Basically, this whole bit is useless code, even the small
   * implementation here is only because of overspecification.
   */
  ppp_slprintf(message, message_space, "E=691 R=1 C=%0.*B V=0 M=%s",
               challenge_len, challenge, "Access denied");
  return 0;
}
#endif /* PPP_SERVER */

static void chapms_make_response(ppp_pcb *pcb, unsigned char *response, int id,
                                 const char *our_name,
                                 const unsigned char *challenge,
                                 const char *secret, int secret_len,
                                 unsigned char *private_) {
  LWIP_UNUSED_ARG(id);
  LWIP_UNUSED_ARG(our_name);
  LWIP_UNUSED_ARG(private_);
  challenge++; /* skip length, should be 8 */
  *response++ = MS_CHAP_RESPONSE_LEN;
  ChapMS(pcb, challenge, secret, secret_len, response);
}

static void chapms2_make_response(ppp_pcb *pcb, unsigned char *response, int id,
                                  const char *our_name,
                                  const unsigned char *challenge,
                                  const char *secret, int secret_len,
                                  unsigned char *private_) {
  LWIP_UNUSED_ARG(id);
  challenge++; /* skip length, should be 16 */
  *response++ = MS_CHAP2_RESPONSE_LEN;
  ChapMS2(pcb, challenge,
#ifdef DEBUGMPPEKEY
          mschap2_peer_challenge,
#else
          NULL,
#endif
          our_name, secret, secret_len, response, private_,
          MS_CHAP2_AUTHENTICATEE);
}

static int chapms2_check_success(ppp_pcb *pcb, unsigned char *msg, int len,
                                 unsigned char *private_) {
  LWIP_UNUSED_ARG(pcb);

  if ((len < MS_AUTH_RESPONSE_LENGTH + 2) ||
      strncmp((char *)msg, "S=", 2) != 0) {
    /* Packet does not start with "S=" */
    ppp_error(("MS-CHAPv2 Success packet is badly formed."));
    return 0;
  }
  msg += 2;
  len -= 2;
  if (len < MS_AUTH_RESPONSE_LENGTH ||
      memcmp(msg, private_, MS_AUTH_RESPONSE_LENGTH)) {
    /* Authenticator Response did not match expected. */
    ppp_error(("MS-CHAPv2 mutual authentication failed."));
    return 0;
  }
  /* Authenticator Response matches. */
  msg += MS_AUTH_RESPONSE_LENGTH; /* Eat it */
  len -= MS_AUTH_RESPONSE_LENGTH;
  if ((len >= 3) && !strncmp((char *)msg, " M=", 3)) {
    msg += 3; /* Eat the delimiter */
  } else if (len) {
    /* Packet has extra text which does not begin " M=" */
    ppp_error(("MS-CHAPv2 Success packet is badly formed."));
    return 0;
  }
  return 1;
}

static void chapms_handle_failure(ppp_pcb *pcb, unsigned char *inp, int len) {
  int err;
  const char *p;
  char msg[64];
  LWIP_UNUSED_ARG(pcb);

  /* We want a null-terminated string for strxxx(). */
  len = LWIP_MIN(len, 63);
  MEMCPY(msg, inp, len);
  msg[len] = 0;
  p = msg;

  /*
   * Deal with MS-CHAP formatted failure messages; just print the
   * M=<message> part (if any).  For MS-CHAP we're not really supposed
   * to use M=<message>, but it shouldn't hurt.  See
   * chapms[2]_verify_response.
   */
  if (!strncmp(p, "E=", 2))
    err = strtol(p + 2, NULL, 10); /* Remember the error code. */
  else
    goto print_msg; /* Message is badly formatted. */

  if (len && ((p = strstr(p, " M=")) != NULL)) {
    /* M=<message> field found. */
    p += 3;
  } else {
    /* No M=<message>; use the error code. */
    switch (err) {
    case MS_CHAP_ERROR_RESTRICTED_LOGON_HOURS:
      p = "E=646 Restricted logon hours";
      break;

    case MS_CHAP_ERROR_ACCT_DISABLED:
      p = "E=647 Account disabled";
      break;

    case MS_CHAP_ERROR_PASSWD_EXPIRED:
      p = "E=648 Password expired";
      break;

    case MS_CHAP_ERROR_NO_DIALIN_PERMISSION:
      p = "E=649 No dialin permission";
      break;

    case MS_CHAP_ERROR_AUTHENTICATION_FAILURE:
      p = "E=691 Authentication failure";
      break;

    case MS_CHAP_ERROR_CHANGING_PASSWORD:
      /* Should never see this, we don't support Change Password. */
      p = "E=709 Error changing password";
      break;

    default:
      ppp_error(("Unknown MS-CHAP authentication failure: %.*v", len, inp));
      return;
    }
  }
print_msg:
  if (p != NULL)
    ppp_error(("MS-CHAP authentication failed: %v", p));
}

static void ChallengeResponse(const u_char *challenge,
                              const u_char PasswordHash[MD4_SIGNATURE_SIZE],
                              u_char response[24]) {
  u_char ZPasswordHash[21];
  lwip_des_context des;
  u_char des_key[8];

  BZERO(ZPasswordHash, sizeof(ZPasswordHash));
  MEMCPY(ZPasswordHash, PasswordHash, MD4_SIGNATURE_SIZE);

#if 0
    dbglog("ChallengeResponse - ZPasswordHash %.*B",
	   sizeof(ZPasswordHash), ZPasswordHash);
#endif

  pppcrypt_56_to_64_bit_key(ZPasswordHash + 0, des_key);
  lwip_des_init(&des);
  lwip_des_setkey_enc(&des, des_key);
  lwip_des_crypt_ecb(&des, challenge, response + 0);
  lwip_des_free(&des);

  pppcrypt_56_to_64_bit_key(ZPasswordHash + 7, des_key);
  lwip_des_init(&des);
  lwip_des_setkey_enc(&des, des_key);
  lwip_des_crypt_ecb(&des, challenge, response + 8);
  lwip_des_free(&des);

  pppcrypt_56_to_64_bit_key(ZPasswordHash + 14, des_key);
  lwip_des_init(&des);
  lwip_des_setkey_enc(&des, des_key);
  lwip_des_crypt_ecb(&des, challenge, response + 16);
  lwip_des_free(&des);

#if 0
    dbglog("ChallengeResponse - response %.24B", response);
#endif
}

static void ChallengeHash(const u_char PeerChallenge[16],
                          const u_char *rchallenge, const char *username,
                          u_char Challenge[8]) {
  lwip_sha1_context sha1Context;
  u_char sha1Hash[SHA1_SIGNATURE_SIZE];
  const char *user;

  /* remove domain from "domain\username" */
  if ((user = strrchr(username, '\\')) != NULL)
    ++user;
  else
    user = username;

  lwip_sha1_init(&sha1Context);
  lwip_sha1_starts(&sha1Context);
  lwip_sha1_update(&sha1Context, PeerChallenge, 16);
  lwip_sha1_update(&sha1Context, rchallenge, 16);
  lwip_sha1_update(&sha1Context, (const unsigned char *)user, strlen(user));
  lwip_sha1_finish(&sha1Context, sha1Hash);
  lwip_sha1_free(&sha1Context);

  MEMCPY(Challenge, sha1Hash, 8);
}

/*
 * Convert the ASCII version of the password to Unicode.
 * This implicitly supports 8-bit ISO8859/1 characters.
 * This gives us the little-endian representation, which
 * is assumed by all M$ CHAP RFCs.  (Unicode byte ordering
 * is machine-dependent.)
 */
static void ascii2unicode(const char ascii[], int ascii_len, u_char unicode[]) {
  int i;

  BZERO(unicode, ascii_len * 2);
  for (i = 0; i < ascii_len; i++)
    unicode[i * 2] = (u_char)ascii[i];
}

static void NTPasswordHash(u_char *secret, int secret_len,
                           u_char hash[MD4_SIGNATURE_SIZE]) {
  lwip_md4_context md4Context;

  lwip_md4_init(&md4Context);
  lwip_md4_starts(&md4Context);
  lwip_md4_update(&md4Context, secret, secret_len);
  lwip_md4_finish(&md4Context, hash);
  lwip_md4_free(&md4Context);
}

static void ChapMS_NT(const u_char *rchallenge, const char *secret,
                      int secret_len, u_char NTResponse[24]) {
  u_char unicodePassword[MAX_NT_PASSWORD * 2];
  u_char PasswordHash[MD4_SIGNATURE_SIZE];

  /* Hash the Unicode version of the secret (== password). */
  ascii2unicode(secret, secret_len, unicodePassword);
  NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);

  ChallengeResponse(rchallenge, PasswordHash, NTResponse);
}

static void ChapMS2_NT(const u_char *rchallenge, const u_char PeerChallenge[16],
                       const char *username, const char *secret, int secret_len,
                       u_char NTResponse[24]) {
  u_char unicodePassword[MAX_NT_PASSWORD * 2];
  u_char PasswordHash[MD4_SIGNATURE_SIZE];
  u_char Challenge[8];

  ChallengeHash(PeerChallenge, rchallenge, username, Challenge);

  /* Hash the Unicode version of the secret (== password). */
  ascii2unicode(secret, secret_len, unicodePassword);
  NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);

  ChallengeResponse(Challenge, PasswordHash, NTResponse);
}

#ifdef MSLANMAN
static u_char *StdText = (u_char *)"KGS!@#$%"; /* key from rasapi32.dll */

static void ChapMS_LANMan(u_char *rchallenge, char *secret, int secret_len,
                          unsigned char *response) {
  int i;
  u_char UcasePassword[MAX_NT_PASSWORD]; /* max is actually 14 */
  u_char PasswordHash[MD4_SIGNATURE_SIZE];
  lwip_des_context des;
  u_char des_key[8];

  /* LANMan password is case insensitive */
  BZERO(UcasePassword, sizeof(UcasePassword));
  for (i = 0; i < secret_len; i++)
    UcasePassword[i] = (u_char)toupper(secret[i]);

  pppcrypt_56_to_64_bit_key(UcasePassword + 0, des_key);
  lwip_des_init(&des);
  lwip_des_setkey_enc(&des, des_key);
  lwip_des_crypt_ecb(&des, StdText, PasswordHash + 0);
  lwip_des_free(&des);

  pppcrypt_56_to_64_bit_key(UcasePassword + 7, des_key);
  lwip_des_init(&des);
  lwip_des_setkey_enc(&des, des_key);
  lwip_des_crypt_ecb(&des, StdText, PasswordHash + 8);
  lwip_des_free(&des);

  ChallengeResponse(rchallenge, PasswordHash, &response[MS_CHAP_LANMANRESP]);
}
#endif

static void GenerateAuthenticatorResponse(
    const u_char PasswordHashHash[MD4_SIGNATURE_SIZE], u_char NTResponse[24],
    const u_char PeerChallenge[16], const u_char *rchallenge,
    const char *username, u_char authResponse[MS_AUTH_RESPONSE_LENGTH + 1]) {
  /*
   * "Magic" constants used in response generation, from RFC 2759.
   */
  static const u_char
      Magic1[39] = /* "Magic server to client signing constant" */
      {0x4D, 0x61, 0x67, 0x69, 0x63, 0x20, 0x73, 0x65, 0x72, 0x76,
       0x65, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x63, 0x6C, 0x69, 0x65,
       0x6E, 0x74, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x69, 0x6E, 0x67,
       0x20, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x74};
  static const u_char
      Magic2[41] = /* "Pad to make it do more than one iteration" */
      {0x50, 0x61, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x6D, 0x61, 0x6B, 0x65,
       0x20, 0x69, 0x74, 0x20, 0x64, 0x6F, 0x20, 0x6D, 0x6F, 0x72, 0x65,
       0x20, 0x74, 0x68, 0x61, 0x6E, 0x20, 0x6F, 0x6E, 0x65, 0x20, 0x69,
       0x74, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E};

  int i;
  lwip_sha1_context sha1Context;
  u_char Digest[SHA1_SIGNATURE_SIZE];
  u_char Challenge[8];

  lwip_sha1_init(&sha1Context);
  lwip_sha1_starts(&sha1Context);
  lwip_sha1_update(&sha1Context, PasswordHashHash, MD4_SIGNATURE_SIZE);
  lwip_sha1_update(&sha1Context, NTResponse, 24);
  lwip_sha1_update(&sha1Context, Magic1, sizeof(Magic1));
  lwip_sha1_finish(&sha1Context, Digest);
  lwip_sha1_free(&sha1Context);

  ChallengeHash(PeerChallenge, rchallenge, username, Challenge);

  lwip_sha1_init(&sha1Context);
  lwip_sha1_starts(&sha1Context);
  lwip_sha1_update(&sha1Context, Digest, sizeof(Digest));
  lwip_sha1_update(&sha1Context, Challenge, sizeof(Challenge));
  lwip_sha1_update(&sha1Context, Magic2, sizeof(Magic2));
  lwip_sha1_finish(&sha1Context, Digest);
  lwip_sha1_free(&sha1Context);

  /* Convert to ASCII hex string. */
  for (i = 0; i < LWIP_MAX((MS_AUTH_RESPONSE_LENGTH / 2), (int)sizeof(Digest));
       i++)
    sprintf((char *)&authResponse[i * 2], "%02X", Digest[i]);
}

static void GenerateAuthenticatorResponsePlain(
    const char *secret, int secret_len, u_char NTResponse[24],
    const u_char PeerChallenge[16], const u_char *rchallenge,
    const char *username, u_char authResponse[MS_AUTH_RESPONSE_LENGTH + 1]) {
  u_char unicodePassword[MAX_NT_PASSWORD * 2];
  u_char PasswordHash[MD4_SIGNATURE_SIZE];
  u_char PasswordHashHash[MD4_SIGNATURE_SIZE];

  /* Hash (x2) the Unicode version of the secret (== password). */
  ascii2unicode(secret, secret_len, unicodePassword);
  NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
  NTPasswordHash(PasswordHash, sizeof(PasswordHash), PasswordHashHash);

  GenerateAuthenticatorResponse(PasswordHashHash, NTResponse, PeerChallenge,
                                rchallenge, username, authResponse);
}

#if MPPE_SUPPORT
/*
 * Set mppe_xxxx_key from MS-CHAP credentials. (see RFC 3079)
 */
static void Set_Start_Key(ppp_pcb *pcb, const u_char *rchallenge,
                          const char *secret, int secret_len) {
  u_char unicodePassword[MAX_NT_PASSWORD * 2];
  u_char PasswordHash[MD4_SIGNATURE_SIZE];
  u_char PasswordHashHash[MD4_SIGNATURE_SIZE];
  lwip_sha1_context sha1Context;
  u_char Digest[SHA1_SIGNATURE_SIZE]; /* >= MPPE_MAX_KEY_LEN */

  /* Hash (x2) the Unicode version of the secret (== password). */
  ascii2unicode(secret, secret_len, unicodePassword);
  NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
  NTPasswordHash(PasswordHash, sizeof(PasswordHash), PasswordHashHash);

  lwip_sha1_init(&sha1Context);
  lwip_sha1_starts(&sha1Context);
  lwip_sha1_update(&sha1Context, PasswordHashHash, MD4_SIGNATURE_SIZE);
  lwip_sha1_update(&sha1Context, PasswordHashHash, MD4_SIGNATURE_SIZE);
  lwip_sha1_update(&sha1Context, rchallenge, 8);
  lwip_sha1_finish(&sha1Context, Digest);
  lwip_sha1_free(&sha1Context);

  /* Same key in both directions. */
  mppe_set_key(pcb, &pcb->mppe_comp, Digest);
  mppe_set_key(pcb, &pcb->mppe_decomp, Digest);

  pcb->mppe_keys_set = 1;
}

/*
 * Set mppe_xxxx_key from MS-CHAPv2 credentials. (see RFC 3079)
 */
static void SetMasterKeys(ppp_pcb *pcb, const char *secret, int secret_len,
                          u_char NTResponse[24], int IsServer) {
  u_char unicodePassword[MAX_NT_PASSWORD * 2];
  u_char PasswordHash[MD4_SIGNATURE_SIZE];
  u_char PasswordHashHash[MD4_SIGNATURE_SIZE];
  lwip_sha1_context sha1Context;
  u_char MasterKey[SHA1_SIGNATURE_SIZE]; /* >= MPPE_MAX_KEY_LEN */
  u_char Digest[SHA1_SIGNATURE_SIZE];    /* >= MPPE_MAX_KEY_LEN */
  const u_char *s;

  /* "This is the MPPE Master Key" */
  static const u_char Magic1[27] = {0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73,
                                    0x20, 0x74, 0x68, 0x65, 0x20, 0x4d, 0x50,
                                    0x50, 0x45, 0x20, 0x4d, 0x61, 0x73, 0x74,
                                    0x65, 0x72, 0x20, 0x4b, 0x65, 0x79};
  /* "On the client side, this is the send key; "
     "on the server side, it is the receive key." */
  static const u_char Magic2[84] = {
      0x4f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e,
      0x74, 0x20, 0x73, 0x69, 0x64, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73,
      0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64,
      0x20, 0x6b, 0x65, 0x79, 0x3b, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65,
      0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x73, 0x69, 0x64, 0x65,
      0x2c, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20,
      0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x2e};
  /* "On the client side, this is the receive key; "
     "on the server side, it is the send key." */
  static const u_char Magic3[84] = {
      0x4f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e,
      0x74, 0x20, 0x73, 0x69, 0x64, 0x65, 0x2c, 0x20, 0x74, 0x68, 0x69, 0x73,
      0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x63, 0x65,
      0x69, 0x76, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x3b, 0x20, 0x6f, 0x6e, 0x20,
      0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x73,
      0x69, 0x64, 0x65, 0x2c, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x74,
      0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x20, 0x6b, 0x65, 0x79, 0x2e};

  /* Hash (x2) the Unicode version of the secret (== password). */
  ascii2unicode(secret, secret_len, unicodePassword);
  NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
  NTPasswordHash(PasswordHash, sizeof(PasswordHash), PasswordHashHash);

  lwip_sha1_init(&sha1Context);
  lwip_sha1_starts(&sha1Context);
  lwip_sha1_update(&sha1Context, PasswordHashHash, MD4_SIGNATURE_SIZE);
  lwip_sha1_update(&sha1Context, NTResponse, 24);
  lwip_sha1_update(&sha1Context, Magic1, sizeof(Magic1));
  lwip_sha1_finish(&sha1Context, MasterKey);
  lwip_sha1_free(&sha1Context);

  /*
   * generate send key
   */
  if (IsServer)
    s = Magic3;
  else
    s = Magic2;
  lwip_sha1_init(&sha1Context);
  lwip_sha1_starts(&sha1Context);
  lwip_sha1_update(&sha1Context, MasterKey, 16);
  lwip_sha1_update(&sha1Context, mppe_sha1_pad1, SHA1_PAD_SIZE);
  lwip_sha1_update(&sha1Context, s, 84);
  lwip_sha1_update(&sha1Context, mppe_sha1_pad2, SHA1_PAD_SIZE);
  lwip_sha1_finish(&sha1Context, Digest);
  lwip_sha1_free(&sha1Context);

  mppe_set_key(pcb, &pcb->mppe_comp, Digest);

  /*
   * generate recv key
   */
  if (IsServer)
    s = Magic2;
  else
    s = Magic3;
  lwip_sha1_init(&sha1Context);
  lwip_sha1_starts(&sha1Context);
  lwip_sha1_update(&sha1Context, MasterKey, 16);
  lwip_sha1_update(&sha1Context, mppe_sha1_pad1, SHA1_PAD_SIZE);
  lwip_sha1_update(&sha1Context, s, 84);
  lwip_sha1_update(&sha1Context, mppe_sha1_pad2, SHA1_PAD_SIZE);
  lwip_sha1_finish(&sha1Context, Digest);
  lwip_sha1_free(&sha1Context);

  mppe_set_key(pcb, &pcb->mppe_decomp, Digest);

  pcb->mppe_keys_set = 1;
}

#endif /* MPPE_SUPPORT */

static void ChapMS(ppp_pcb *pcb, const u_char *rchallenge, const char *secret,
                   int secret_len, unsigned char *response) {
#if !MPPE_SUPPORT
  LWIP_UNUSED_ARG(pcb);
#endif /* !MPPE_SUPPORT */
  BZERO(response, MS_CHAP_RESPONSE_LEN);

  ChapMS_NT(rchallenge, secret, secret_len, &response[MS_CHAP_NTRESP]);

#ifdef MSLANMAN
  ChapMS_LANMan(rchallenge, secret, secret_len, &response[MS_CHAP_LANMANRESP]);

  /* preferred method is set by option  */
  response[MS_CHAP_USENT] = !ms_lanman;
#else
  response[MS_CHAP_USENT] = 1;
#endif

#if MPPE_SUPPORT
  Set_Start_Key(pcb, rchallenge, secret, secret_len);
#endif /* MPPE_SUPPORT */
}

/*
 * If PeerChallenge is NULL, one is generated and the PeerChallenge
 * field of response is filled in.  Call this way when generating a response.
 * If PeerChallenge is supplied, it is copied into the PeerChallenge field.
 * Call this way when verifying a response (or debugging).
 * Do not call with PeerChallenge = response.
 *
 * The PeerChallenge field of response is then used for calculation of the
 * Authenticator Response.
 */
static void ChapMS2(ppp_pcb *pcb, const u_char *rchallenge,
                    const u_char *PeerChallenge, const char *user,
                    const char *secret, int secret_len, unsigned char *response,
                    u_char authResponse[], int authenticator) {
  /* ARGSUSED */
  LWIP_UNUSED_ARG(authenticator);
#if !MPPE_SUPPORT
  LWIP_UNUSED_ARG(pcb);
#endif /* !MPPE_SUPPORT */

  BZERO(response, MS_CHAP2_RESPONSE_LEN);

  /* Generate the Peer-Challenge if requested, or copy it if supplied. */
  if (!PeerChallenge)
    magic_random_bytes(&response[MS_CHAP2_PEER_CHALLENGE],
                       MS_CHAP2_PEER_CHAL_LEN);
  else
    MEMCPY(&response[MS_CHAP2_PEER_CHALLENGE], PeerChallenge,
           MS_CHAP2_PEER_CHAL_LEN);

  /* Generate the NT-Response */
  ChapMS2_NT(rchallenge, &response[MS_CHAP2_PEER_CHALLENGE], user, secret,
             secret_len, &response[MS_CHAP2_NTRESP]);

  /* Generate the Authenticator Response. */
  GenerateAuthenticatorResponsePlain(
      secret, secret_len, &response[MS_CHAP2_NTRESP],
      &response[MS_CHAP2_PEER_CHALLENGE], rchallenge, user, authResponse);

#if MPPE_SUPPORT
  SetMasterKeys(pcb, secret, secret_len, &response[MS_CHAP2_NTRESP],
                authenticator);
#endif /* MPPE_SUPPORT */
}

#if 0 /* UNUSED */
#if MPPE_SUPPORT
/*
 * Set MPPE options from plugins.
 */
void set_mppe_enc_types(int policy, int types) {
    /* Early exit for unknown policies. */
    if (policy != MPPE_ENC_POL_ENC_ALLOWED ||
	policy != MPPE_ENC_POL_ENC_REQUIRED)
	return;

    /* Don't modify MPPE if it's optional and wasn't already configured. */
    if (policy == MPPE_ENC_POL_ENC_ALLOWED && !ccp_wantoptions[0].mppe)
	return;

    /*
     * Disable undesirable encryption types.  Note that we don't ENABLE
     * any encryption types, to avoid overriding manual configuration.
     */
    switch(types) {
	case MPPE_ENC_TYPES_RC4_40:
	    ccp_wantoptions[0].mppe &= ~MPPE_OPT_128;	/* disable 128-bit */
	    break;
	case MPPE_ENC_TYPES_RC4_128:
	    ccp_wantoptions[0].mppe &= ~MPPE_OPT_40;	/* disable 40-bit */
	    break;
	default:
	    break;
    }
}
#endif /* MPPE_SUPPORT */
#endif /* UNUSED */

const struct chap_digest_type chapms_digest = {
    CHAP_MICROSOFT, /* code */
#if PPP_SERVER
    chapms_generate_challenge,
    chapms_verify_response,
#endif /* PPP_SERVER */
    chapms_make_response,
    NULL, /* check_success */
    chapms_handle_failure,
};

const struct chap_digest_type chapms2_digest = {
    CHAP_MICROSOFT_V2, /* code */
#if PPP_SERVER
    chapms2_generate_challenge, chapms2_verify_response,
#endif /* PPP_SERVER */
    chapms2_make_response,      chapms2_check_success,   chapms_handle_failure,
};

#endif /* PPP_SUPPORT && MSCHAP_SUPPORT */
